<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=11"/>
<meta name="generator" content="Doxygen 1.9.4"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Flow: flow::log Namespace Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr id="projectrow">
  <td id="projectalign">
   <div id="projectname">Flow<span id="projectnumber">&#160;2.0.0</span>
   </div>
   <div id="projectbrief">Flow project: Public API.</div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.4 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
var searchBox = new SearchBox("searchBox", "search",'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */
</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceflow.html">flow</a></li><li class="navelem"><a class="el" href="namespaceflow_1_1log.html">log</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#namespaces">Namespaces</a> &#124;
<a href="#nested-classes">Classes</a> &#124;
<a href="#enum-members">Enumerations</a> &#124;
<a href="#func-members">Functions</a>  </div>
  <div class="headertitle"><div class="title">flow::log Namespace Reference</div></div>
</div><!--header-->
<div class="contents">

<p>Flow module providing logging functionality.  
<a href="namespaceflow_1_1log.html#details">More...</a></p>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="namespaces" name="namespaces"></a>
Namespaces</h2></td></tr>
<tr class="memitem:namespaceflow_1_1log_1_1fs"><td class="memItemLeft" align="right" valign="top">namespace &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log_1_1fs.html">fs</a></td></tr>
<tr class="memdesc:namespaceflow_1_1log_1_1fs"><td class="mdescLeft">&#160;</td><td class="mdescRight">Short-hand for <code>namespace <a class="el" href="namespaceboost_1_1filesystem.html" title="We may add some ADL-based overloads into this namespace outside flow.">boost::filesystem</a></code>. <br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="nested-classes" name="nested-classes"></a>
Classes</h2></td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Async__file__logger.html">Async_file_logger</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">An implementation of <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> that logs messages to a given file-system path but never blocks any logging thread for file I/O; suitable for heavy-duty file logging.  <a href="classflow_1_1log_1_1Async__file__logger.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Buffer__logger.html">Buffer_logger</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">An implementation of <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> that logs messages to an internal <code>std::string</code> buffer and provides read-only access to this buffer (for example, if one wants to write out its contents when exiting program).  <a href="classflow_1_1log_1_1Buffer__logger.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Component.html">Component</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">A light-weight class, each object storing a <em>component</em> payload encoding an <code>enum</code> value from <code>enum</code> type of user's choice, and a light-weight ID of that <code>enum</code> type itself.  <a href="classflow_1_1log_1_1Component.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Config.html">Config</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Class used to configure the filtering and logging behavior of <code><a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a></code>s; its use in your custom <code><a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a></code>s is optional but encouraged; supports dynamically changing filter settings even while concurrent logging occurs.  <a href="classflow_1_1log_1_1Config.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Log__context.html">Log_context</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Convenience class that simply stores a <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> and/or <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">Component</a> passed into a constructor; and returns this <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> and <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">Component</a> via <a class="el" href="classflow_1_1log_1_1Log__context.html#af4db395042b065b00398cd59845dcb4d" title="Returns the stored Logger pointer, particularly as many FLOW_LOG_*() macros expect.">get_logger()</a> and <a class="el" href="classflow_1_1log_1_1Log__context.html#a8a5fef42dc2cedf3c0d1a6e83beb2948" title="Returns reference to the stored Component object, particularly as many FLOW_LOG_*() macros expect.">get_log_component()</a> public accessors.  <a href="classflow_1_1log_1_1Log__context.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Logger.html">Logger</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Interface that the user should implement, passing the implementing <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> into logging classes (Flow's own classes like <a class="el" href="classflow_1_1net__flow_1_1Node.html" title="An object of this class is a single Flow-protocol networking node, in the sense that: (1) it has a di...">net_flow::Node</a>; and user's own logging classes) at construction (plus free/<code>static</code> logging functions).  <a href="classflow_1_1log_1_1Logger.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structflow_1_1log_1_1Msg__metadata.html">Msg_metadata</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Simple data store containing all of the information generated at every logging call site by <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a>, except the message itself, which is passed to <a class="el" href="classflow_1_1log_1_1Logger.html#a934667f16dd6ca0841e521296ab3a6e2" title="Given a message and its severity, logs that message and possibly severity WITHOUT checking whether it...">Logger::do_log()</a> assuming <a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">Logger::should_log()</a> had returned <code>true</code>.  <a href="structflow_1_1log_1_1Msg__metadata.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Ostream__log__msg__writer.html">Ostream_log_msg_writer</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Utility class, each object of which wraps a given <code>ostream</code> and outputs discrete messages to it adorned with time stamps and other formatting such as separating newlines.  <a href="classflow_1_1log_1_1Ostream__log__msg__writer.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Simple__ostream__logger.html">Simple_ostream_logger</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">An implementation of <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> that logs messages to the given <code>ostream</code>s (e.g., <code>cout</code> or an <code>ofstream</code> for a file).  <a href="classflow_1_1log_1_1Simple__ostream__logger.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from a config source (like an options file) in concise form and apply it to a <a class="el" href="classflow_1_1log_1_1Config.html" title="Class used to configure the filtering and logging behavior of Loggers; its use in your custom Loggers...">log::Config</a> object.  <a href="classflow_1_1log_1_1Verbosity__config.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="enum-members" name="enum-members"></a>
Enumerations</h2></td></tr>
<tr class="memitem:a5c602384e6fe9d7642740ac2fae4ad04"><td class="memItemLeft" align="right" valign="top">enum class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">Sev</a> : size_t { <br />
&#160;&#160;<a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a9ed9d44ce5760f61ea506d5571343624">S_NONE</a> = 0
, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac90b5a22c7659cc99e7a6d919a14b660">S_FATAL</a>
, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aac04e40d3b2f54f1f517d49594eb7849">S_ERROR</a>
, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021">S_WARNING</a>
, <br />
&#160;&#160;<a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7">S_INFO</a>
, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aa6874010df179b46ffec47aaf9bc1358">S_DEBUG</a>
, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">S_TRACE</a>
, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed">S_DATA</a>
, <br />
&#160;&#160;<a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a6fba12db09e5bebfaa04f6372c41c2cf">S_END_SENTINEL</a>
<br />
 }</td></tr>
<tr class="memdesc:a5c602384e6fe9d7642740ac2fae4ad04"><td class="mdescLeft">&#160;</td><td class="mdescRight">Enumeration containing one of several message severity levels, ordered from highest to lowest.  <a href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">More...</a><br /></td></tr>
<tr class="separator:a5c602384e6fe9d7642740ac2fae4ad04"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="func-members" name="func-members"></a>
Functions</h2></td></tr>
<tr class="memitem:a1b475cd2cc2e476aa96c002927bf1690"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#a1b475cd2cc2e476aa96c002927bf1690">swap</a> (<a class="el" href="classflow_1_1log_1_1Log__context.html">Log_context</a> &amp;val1, <a class="el" href="classflow_1_1log_1_1Log__context.html">Log_context</a> &amp;val2)</td></tr>
<tr class="memdesc:a1b475cd2cc2e476aa96c002927bf1690"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">Log_context</a> ADL-friendly swap: Equivalent to <code>val1.swap(val2)</code>.  <a href="namespaceflow_1_1log.html#a1b475cd2cc2e476aa96c002927bf1690">More...</a><br /></td></tr>
<tr class="separator:a1b475cd2cc2e476aa96c002927bf1690"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a06c8c59ea6c9b36c25b9b8ef319ba501"><td class="memItemLeft" align="right" valign="top">std::ostream &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#a06c8c59ea6c9b36c25b9b8ef319ba501">operator&lt;&lt;</a> (std::ostream &amp;os, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">Sev</a> val)</td></tr>
<tr class="memdesc:a06c8c59ea6c9b36c25b9b8ef319ba501"><td class="mdescLeft">&#160;</td><td class="mdescRight">Serializes a <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> to a standard output stream.  <a href="namespaceflow_1_1log.html#a06c8c59ea6c9b36c25b9b8ef319ba501">More...</a><br /></td></tr>
<tr class="separator:a06c8c59ea6c9b36c25b9b8ef319ba501"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a350b25cb85d91052c0fb3dd80d513056"><td class="memItemLeft" align="right" valign="top">std::istream &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#a350b25cb85d91052c0fb3dd80d513056">operator&gt;&gt;</a> (std::istream &amp;is, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">Sev</a> &amp;val)</td></tr>
<tr class="memdesc:a350b25cb85d91052c0fb3dd80d513056"><td class="mdescLeft">&#160;</td><td class="mdescRight">Deserializes a <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> from a standard input stream.  <a href="namespaceflow_1_1log.html#a350b25cb85d91052c0fb3dd80d513056">More...</a><br /></td></tr>
<tr class="separator:a350b25cb85d91052c0fb3dd80d513056"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aaaaa1dcbf7c8dc99aceb2b6c217187fc"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#aaaaa1dcbf7c8dc99aceb2b6c217187fc">beautify_chrono_logger_this_thread</a> (<a class="el" href="classflow_1_1log_1_1Logger.html">Logger</a> *logger_ptr)</td></tr>
<tr class="memdesc:aaaaa1dcbf7c8dc99aceb2b6c217187fc"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets certain <code>chrono</code>-related formatting on the given <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> in the current thread that results in a consistent, desirable output of <code>duration</code>s and certain types of <code>time_point</code>s.  <a href="namespaceflow_1_1log.html#aaaaa1dcbf7c8dc99aceb2b6c217187fc">More...</a><br /></td></tr>
<tr class="separator:aaaaa1dcbf7c8dc99aceb2b6c217187fc"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a267187e63c6355704f547d794c776747"><td class="memItemLeft" align="right" valign="top">size_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#a267187e63c6355704f547d794c776747">deep_size</a> (const <a class="el" href="structflow_1_1log_1_1Msg__metadata.html">Msg_metadata</a> &amp;val)</td></tr>
<tr class="memdesc:a267187e63c6355704f547d794c776747"><td class="mdescLeft">&#160;</td><td class="mdescRight">Estimate of memory footprint of the given value, including memory allocated on its behalf &ndash; but excluding its shallow <code>sizeof</code>! &ndash; in bytes.  <a href="namespaceflow_1_1log.html#a267187e63c6355704f547d794c776747">More...</a><br /></td></tr>
<tr class="separator:a267187e63c6355704f547d794c776747"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab7770a6970cce952c422c27f0bf57d8d"><td class="memItemLeft" align="right" valign="top">std::istream &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#ab7770a6970cce952c422c27f0bf57d8d">operator&gt;&gt;</a> (std::istream &amp;is, <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;val)</td></tr>
<tr class="memdesc:ab7770a6970cce952c422c27f0bf57d8d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Deserializes a <a class="el" href="classflow_1_1log_1_1Verbosity__config.html" title="Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from ...">Verbosity_config</a> from a standard input stream by invoking <code>val.parse(is)</code>.  <a href="namespaceflow_1_1log.html#ab7770a6970cce952c422c27f0bf57d8d">More...</a><br /></td></tr>
<tr class="separator:ab7770a6970cce952c422c27f0bf57d8d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8cf08ca4573526c68e0164a6915b6e44"><td class="memItemLeft" align="right" valign="top">std::ostream &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#a8cf08ca4573526c68e0164a6915b6e44">operator&lt;&lt;</a> (std::ostream &amp;os, const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;val)</td></tr>
<tr class="memdesc:a8cf08ca4573526c68e0164a6915b6e44"><td class="mdescLeft">&#160;</td><td class="mdescRight">Serializes a <a class="el" href="classflow_1_1log_1_1Verbosity__config.html" title="Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from ...">Verbosity_config</a> to a standard output stream.  <a href="namespaceflow_1_1log.html#a8cf08ca4573526c68e0164a6915b6e44">More...</a><br /></td></tr>
<tr class="separator:a8cf08ca4573526c68e0164a6915b6e44"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abfd655adc908d249fe66baf6e8e426e6"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#abfd655adc908d249fe66baf6e8e426e6">operator==</a> (const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;val1, const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;val2)</td></tr>
<tr class="memdesc:abfd655adc908d249fe66baf6e8e426e6"><td class="mdescLeft">&#160;</td><td class="mdescRight">Checks for exact equality of two <a class="el" href="classflow_1_1log_1_1Verbosity__config.html" title="Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from ...">Verbosity_config</a> objects.  <a href="namespaceflow_1_1log.html#abfd655adc908d249fe66baf6e8e426e6">More...</a><br /></td></tr>
<tr class="separator:abfd655adc908d249fe66baf6e8e426e6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acf78eb12c635e06cb37dfbcaac70144d"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html#acf78eb12c635e06cb37dfbcaac70144d">operator!=</a> (const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;val1, const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;val2)</td></tr>
<tr class="memdesc:acf78eb12c635e06cb37dfbcaac70144d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns <code>!(val1 == val2)</code>.  <a href="namespaceflow_1_1log.html#acf78eb12c635e06cb37dfbcaac70144d">More...</a><br /></td></tr>
<tr class="separator:acf78eb12c635e06cb37dfbcaac70144d"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p >Flow module providing logging functionality. </p>
<p >While originally intended to be used from within the <a class="el" href="namespaceflow_1_1net__flow.html" title="Flow module containing the API and implementation of the Flow network protocol, a TCP-inspired stream...">flow::net_flow</a> module's implementation, it can be used by general user code as well. All other Flow modules expose <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> concepts when logging is relevant, so one way or another the user is likely to have at least limited contact with <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> if they use Flow at all. (In particular, classes and free/<code>static</code> functions in various Flow modules often take a <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> pointer as a constructor or function argument respectively. Hence to use such APIs one must instantiate a concrete <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a>, the simplest choice being probably <a class="el" href="classflow_1_1log_1_1Simple__ostream__logger.html" title="An implementation of Logger that logs messages to the given ostreams (e.g., cout or an ofstream for a...">Simple_ostream_logger</a>.)</p>
<p >(The general user [in their own, non-Flow-related code] may well prefer to use another logging system directly instead; or use boost.log. However, we humbly recommend taking a look at <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> as a possibility, as it is highly usable, yet fast, yet small and elegant enough to ensure complete visibility into its low-level behavior, including how that affects performance. Note also that this system easily integrates with others via <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">log::Logger</a> interface, so one can stack this on top of perhaps a lower-level logging facility. The performance cost of this is essentially 1-2 <code>virtual</code> pointer lookups per log-message call.)</p>
<p >Log philosophy of Flow is as follows. The following is a list of goals; and for each item, sub-item(s) explain how this goal is accomplished.</p>
<ul>
<li>Flow is a library or set of libraries &ndash; not an application or set of applications &ndash; so logging has to flexibly work with any logging system the user code may use.<ul>
<li>The <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> interface provides a way to efficiently log to an arbitrary logging output; the <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> user must provide a simple <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> implementation that fills in what <a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">Logger::should_log()</a> and <a class="el" href="classflow_1_1log_1_1Logger.html#a934667f16dd6ca0841e521296ab3a6e2" title="Given a message and its severity, logs that message and possibly severity WITHOUT checking whether it...">Logger::do_log()</a> mean.</li>
<li>To ensure maximum simplicity and usability right out of the box, <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> provides a <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> implementation, <a class="el" href="classflow_1_1log_1_1Simple__ostream__logger.html" title="An implementation of Logger that logs messages to the given ostreams (e.g., cout or an ofstream for a...">Simple_ostream_logger</a>, which will log to standard <code>ostream</code>s (including <code>cout</code> and <code>cerr</code>). The user can just use this out of the box and not even have to implement the (already trivial) <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> interface. (Probably most larger projects would need to go beyond this.)</li>
</ul>
</li>
<li>The logging system has to provide both error messages and informational or trace messages, and these should be easily distinguishable once passed on to the user's supplied arbitrary logging output(s).<ul>
<li>There are at least 3 message severities, and they are passed to the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> implementation, so that this can be translated as necessary into the user's logging output(s).</li>
</ul>
</li>
<li>The logging system is not a replacement for error reporting by Flow APIs.<ul>
<li><a class="el" href="namespaceflow.html#a29eaaa9d0fac4ce87d8b969222dbed09" title="Short-hand for a boost.system error code (which basically encapsulates an integer/enum error code and...">flow::Error_code</a> and <a class="el" href="namespaceflow_1_1error.html" title="Flow module that facilitates working with error codes and exceptions; essentially comprised of niceti...">flow::error</a> provide at least error code reporting (in addition to log calls) where possible and applicable.</li>
</ul>
</li>
<li>The logging should be possible to entirely enable, entirely disable, or some reasonable point between these extremes.<ul>
<li>The <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> interface's <a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">Logger::should_log()</a> method allows filtering messages by severity (e.g., allow only WARNING messages) in any desired fashion. There is now also support for setting filtering config by "component" supplied essentially at the log message call site.</li>
</ul>
</li>
<li>If a given message is not ultimately logged due its severity, it should induce no performance or resource penalty (such as that incurred by assembling the message string) beyond the severity check itself.<ul>
<li>The <code>FLOW_LOG_...()</code> macros work with the <code><a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">Logger::should_log()</a></code>/<code><a class="el" href="classflow_1_1log_1_1Logger.html#a934667f16dd6ca0841e521296ab3a6e2" title="Given a message and its severity, logs that message and possibly severity WITHOUT checking whether it...">Logger::do_log()</a></code> APIs to only construct the ultimate message string if the resulting message would be logged.</li>
</ul>
</li>
<li>Logging should be simple without lots of extraneous features.<ul>
<li>A few simple-to-use macros are the main way to log messages; see those first.</li>
<li>Every logged message just has a severity and component, which are <code>enum</code>s, and the text of the message. File/function/line and thread ID info are auto-obtained and maintained along with the messages themselves, via the <code>FLOW_LOG_...()</code> macros. The user need not worry about such mundane but tricky details.</li>
<li>The <code>FLOW_LOG_...()</code> macros assume that <code>get_logger()</code> (in the context where the macro is expanded) returns a <code>Logger*</code> implementation, which is then used for the logging call(s) associated with the message &ndash; typically first the <a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">Logger::should_log()</a> check and then possibly the <a class="el" href="classflow_1_1log_1_1Logger.html#a934667f16dd6ca0841e521296ab3a6e2" title="Given a message and its severity, logs that message and possibly severity WITHOUT checking whether it...">Logger::do_log()</a> message output. Deriving from the supplied <a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">Log_context</a> utility class is an easy way to make this <code>get_logger()</code> available all over the Flow modules' implementations (and should indeed be a technique for the user's own logging code, if indeed they decided to use <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> themselves). </li>
</ul>
</li>
</ul>
</div><h2 class="groupheader">Enumeration Type Documentation</h2>
<a id="a5c602384e6fe9d7642740ac2fae4ad04" name="a5c602384e6fe9d7642740ac2fae4ad04"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a5c602384e6fe9d7642740ac2fae4ad04">&#9670;&nbsp;</a></span>Sev</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">enum class <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">flow::log::Sev</a> : size_t</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">strong</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Enumeration containing one of several message severity levels, ordered from highest to lowest. </p>
<p >Generally speaking, volume/verbosity is inversely proportional to severity, though this is not enforced somehow.</p>
<p >As the underlying type is <code>size_t</code>, and the values are guaranteed to be 0, 1, ... going from lowest to highest verbosity (highest to lowest severity), you may directly use <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> values to index into arrays that arrange one-to-one values in the same order.</p>
<p >The supplied <code>ostream&lt;&lt;</code> operator, together with this <code>enum</code>, is suitable for <a class="el" href="namespaceflow_1_1util.html#a18a29d6a6e65c3b96c52b5cad5971266" title="Deserializes an enum class value from a standard input stream.">util::istream_to_enum()</a>. <code>ostream&gt;&gt;</code> operator is built on the latter and is also supplied. Hence I/O of <code>Sev</code> is available out of the box; this enables parsing in boost.program_options among other things.</p>
<h3>Formal semantics of <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a></h3>
<p >From the point of view of all Flow code, the <em>formal</em> semantics of <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> are as follows:</p><ul>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a9ed9d44ce5760f61ea506d5571343624" title="Sentinel log level that must not be specified for any actual message (at risk of undefined behavior s...">Sev::S_NONE</a> has value 0 and is a start-sentinel.</li>
<li>Non-sentinel severities follow, starting at 1 with no gaps.<ul>
<li>Ordinal comparison is meaningful; lower is termed as more severe/less verbose; higher is therefore termed as less severe/more verbose. These are, formally, only terminology.</li>
</ul>
</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a6fba12db09e5bebfaa04f6372c41c2cf" title="Not an actual value but rather stores the highest numerical payload, useful for validity checks.">Sev::S_END_SENTINEL</a> is the end-sentinel.</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021" title="Message indicates a &quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_WARNING</a> is and always shall be considered the <em>least severe</em> "abnormal" condition. Any additional "abnormal" conditions shall always have more-severe (numerically lower) values. As of this writing, within <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> Flow module, this has only one practical meaning (but that could change): <a class="el" href="classflow_1_1log_1_1Simple__ostream__logger.html" title="An implementation of Logger that logs messages to the given ostreams (e.g., cout or an ofstream for a...">Simple_ostream_logger</a> directs WARNING-and-more-severe messages to its configured <em>error</em> stream (<code>os_for_err</code>); while all the rest are directed to its configured other (regular) stream (<code>os</code>). (For example these might be set to <code>std::cerr</code> and <code>std::cout</code> respectively; or both to <code>std::cout</code>.)</li>
</ul>
<h3>Informal semantics of <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a></h3>
<p >The following are not enforced by any code logic in the <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a> Flow module. However we suggest users understand and consider these, as a haphazard approach to severity selection for a given log call site can cause significant operational problems in a high-volume production environment (at least).</p>
<p >Generally, there are 2 types of log call sites: ones inside Flow; and ones outside (user code). The former (inside Flow) are deliberately minimalistic, so as to use as few severities as possible and thus make severity selection maximally simple and, importantly, unambiguous.</p>
<p >However, logging code outside Flow may require more sophisticated in-use severity sets. Informally we <em>recommend</em> keeping it as simple as inside-Flow's scheme... if it is sufficient. If it is not sufficient, the other severities may also be used.</p>
<p >The <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> values used inside Flow (the <em>minimalistic</em> set) are as follows. (Brief meanings accompany them; see their individual doc headers for more detail.) From most to least severe:</p><ul>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac90b5a22c7659cc99e7a6d919a14b660" title="Message indicates a &quot;fatally bad&quot; condition, such that the program shall imminently abort,...">Sev::S_FATAL</a>: the program will abort shortly due to the condition that is being logged. Usually an <code>assert(false)</code> and/or <code>std::abort()</code> follows. If you've disabled abort-on-assertion-trip (<code>NDEBUG</code> is defined), and there is no <code>std::abort()</code> or equivalent, then the program may continue, but subsequent behavior is undefined.</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021" title="Message indicates a &quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_WARNING</a>: abnormal condition is being logged, and its aggregate volume is not high enough to be classified as TRACE instead to avoid perf impact. (Other than possibly FATAL &ndash; used in extreme cases &ndash; no other abnormal-condition <code>Sev</code> are in-use inside Flow nor will they be.)</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" title="Message indicates a not-&quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_INFO</a>: non-abnormal condition is being logged, and it's not so frequent in practice that enabling this log level shall adversely impact performance.</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">Sev::S_TRACE</a>: like INFO, but enabling this log level <em>can</em> adversely impact performance. However, entire dumps of potentially large (in aggregate) data (such as packet contents) being processed are not included.</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">Sev::S_DATA</a>: like TRACE, but entire contents of potentially large (in aggregate) data (such as packet contents) being processed are included in the message, which may lead to particularly large log output (if enabled).</li>
</ul>
<p >As of this writing the following <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> values are available for use (by user/non-Flow code) beyond the above <em>minimalistic</em> set. Potential subjective meanings are included, but user code can use whatever conventions that suit them best.</p><ul>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aac04e40d3b2f54f1f517d49594eb7849" title="Message indicates a &quot;bad&quot; condition with &quot;worse&quot; impact than that of Sev::S_WARNING.">Sev::S_ERROR</a>: A non-FATAL abnormal condition subjectively more severe than WARNING.</li>
<li><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aa6874010df179b46ffec47aaf9bc1358" title="Message indicates a condition with, perhaps, no significant perf impact if enabled (like Sev::S_INFO)...">Sev::S_DEBUG</a>: A non-abnormal condition with, perhaps, non-perf-affecting verbosity (a-la INFO) but subjectively of less interest to a human glancing over a large-ish log snippet (a-la TRACE). </li>
</ul>
<table class="fieldtable">
<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04a9ed9d44ce5760f61ea506d5571343624" name="a5c602384e6fe9d7642740ac2fae4ad04a9ed9d44ce5760f61ea506d5571343624"></a>S_NONE&#160;</td><td class="fielddoc"><p >Sentinel log level that must not be specified for any actual message (at risk of undefined behavior such as assert failure); but can be used for sentinel purposes such as specifying a log filter wherein no messages (not even <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021" title="Message indicates a &quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_WARNING</a> ones) are shown. </p>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04ac90b5a22c7659cc99e7a6d919a14b660" name="a5c602384e6fe9d7642740ac2fae4ad04ac90b5a22c7659cc99e7a6d919a14b660"></a>S_FATAL&#160;</td><td class="fielddoc"><p >Message indicates a "fatally bad" condition, such that the program shall imminently abort, typically due to immediately-following <code>assert(false)</code> and possibly <code>std::abort()</code>; or if aborts are disabled (such as via defining <code>NDEBUG</code>), and there is no explicit <code>std::abort()</code> or equivalent, then further program behavior is undefined. </p>
<dl class="section note"><dt>Note</dt><dd>This severity <em>is</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04aac04e40d3b2f54f1f517d49594eb7849" name="a5c602384e6fe9d7642740ac2fae4ad04aac04e40d3b2f54f1f517d49594eb7849"></a>S_ERROR&#160;</td><td class="fielddoc"><p >Message indicates a "bad" condition with "worse" impact than that of <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021" title="Message indicates a &quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_WARNING</a>. </p>
<dl class="section note"><dt>Note</dt><dd>If it's "bad" but frequent enough for TRACE, we strongly recommend to make it TRACE &ndash; not ERROR.</dd>
<dd>
This severity <em>is NOT</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. Informally we recommend projects do not use it unless it is holistically necessary. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021" name="a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021"></a>S_WARNING&#160;</td><td class="fielddoc"><p >Message indicates a "bad" condition that is not frequent enough to be of severity <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">Sev::S_TRACE</a>. </p>
<p >These typically should occur with less frequency than INFO messages; however, it's not a hard rule.</p>
<dl class="section note"><dt>Note</dt><dd>If it's "bad" but frequent enough for TRACE, it's TRACE by definition &ndash; not WARNING.</dd>
<dd>
This severity <em>is</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" name="a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7"></a>S_INFO&#160;</td><td class="fielddoc"><p >Message indicates a not-"bad" condition that is not frequent enough to be of severity <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">Sev::S_TRACE</a>. </p>
<dl class="section note"><dt>Note</dt><dd>That is, it's identical to WARNING <em>except</em> doesn't represent a "bad" situation.</dd>
<dd>
This severity <em>is</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04aa6874010df179b46ffec47aaf9bc1358" name="a5c602384e6fe9d7642740ac2fae4ad04aa6874010df179b46ffec47aaf9bc1358"></a>S_DEBUG&#160;</td><td class="fielddoc"><p >Message indicates a condition with, perhaps, no significant perf impact if enabled (like <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" title="Message indicates a not-&quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_INFO</a>) but of subjectively less interest to a human reader than INFO (hence, like <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">Sev::S_TRACE</a> in that respect). </p>
<dl class="section note"><dt>Note</dt><dd>This severity <em>is NOT</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. Informally we recommend projects do not use it unless it is holistically necessary. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" name="a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b"></a>S_TRACE&#160;</td><td class="fielddoc"><p >Message indicates any condition that may occur with great frequency (thus verbose if logged). </p>
<p >The line between <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" title="Message indicates a not-&quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_INFO</a> or <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021" title="Message indicates a &quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_WARNING</a> and TRACE is as follows: The former is <em>not</em> allowed to classify messages such that in realistic scenarios they would degrade performance, from processor cycles or log file I/O.</p>
<dl class="section see"><dt>See also</dt><dd><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">Sev::S_DATA</a> for an even-more-verbose severity, when it's frequent and potentially large in size in aggregate.</dd></dl>
<dl class="section warning"><dt>Warning</dt><dd>One MUST be able to set max severity level to INFO and confidently count that logging will not affect performance.</dd></dl>
<dl class="section note"><dt>Note</dt><dd>This severity <em>is</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" name="a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed"></a>S_DATA&#160;</td><td class="fielddoc"><p >Message satisfies <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">Sev::S_TRACE</a> description AND contains variable-length structure (like packet, file) dumps. </p>
<p >If these are allowed to be logged, resulting log file might be roughly similar to (or even larger than) the data being transmitted by the logging code. Packet dumps are obvious examples.</p>
<p >Note that just because it's a variable-length structure dump doesn't mean it's for <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">Sev::S_DATA</a> severity. If it's not frequent, it's fine for it to even be INFO. E.g., if I decide to dump every RST packet, it's probably okay as <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" title="Message indicates a not-&quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">Sev::S_INFO</a>, since RSTs are practically rare; that need not be <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">Sev::S_DATA</a>. On the other hand, if I dump every DATA packet as anything except <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">Sev::S_DATA</a> severity, then I should be arrested and convicted.</p>
<p >When this level is disabled, consider logging a TRACE message instead but summarize the contents you'd dump; e.g., log a hash and/or a size and/or the few first bytes instead of the entire thing. Something is often better than nothing (but nothing is still safer than the whole thing).</p>
<dl class="section note"><dt>Note</dt><dd>This severity <em>is</em> part of the <em>minimalistic</em> (in-use within Flow) severity set as discussed in <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> doc header, "Informal semantics" section. </dd></dl>
</td></tr>
<tr><td class="fieldname"><a id="a5c602384e6fe9d7642740ac2fae4ad04a6fba12db09e5bebfaa04f6372c41c2cf" name="a5c602384e6fe9d7642740ac2fae4ad04a6fba12db09e5bebfaa04f6372c41c2cf"></a>S_END_SENTINEL&#160;</td><td class="fielddoc"><p >Not an actual value but rather stores the highest numerical payload, useful for validity checks. </p>
</td></tr>
</table>

</div>
</div>
<h2 class="groupheader">Function Documentation</h2>
<a id="aaaaa1dcbf7c8dc99aceb2b6c217187fc" name="aaaaa1dcbf7c8dc99aceb2b6c217187fc"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aaaaa1dcbf7c8dc99aceb2b6c217187fc">&#9670;&nbsp;</a></span>beautify_chrono_logger_this_thread()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void flow::log::beautify_chrono_logger_this_thread </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classflow_1_1log_1_1Logger.html">Logger</a> *&#160;</td>
          <td class="paramname"><em>logger_ptr</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Sets certain <code>chrono</code>-related formatting on the given <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> in the current thread that results in a consistent, desirable output of <code>duration</code>s and certain types of <code>time_point</code>s. </p>
<p >The effect is that of <a class="el" href="namespaceflow_1_1util.html#a0955a29930075ac1fe393896c089b911" title="Sets certain chrono-related formatting on the given ostream that results in a consistent,...">util::beautify_chrono_ostream()</a>.</p>
<dl class="section see"><dt>See also</dt><dd><a class="el" href="namespaceflow_1_1async.html" title="Flow module containing tools enabling multi-threaded event loops operating under the asynchronous-tas...">flow::async</a> in which new threads are set to use this formatting automatically. However you'll want to do this explicitly for the startup thread.</dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">logger_ptr</td><td>The <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> to affect in this thread. Null is allowed; results in no-op. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a267187e63c6355704f547d794c776747" name="a267187e63c6355704f547d794c776747"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a267187e63c6355704f547d794c776747">&#9670;&nbsp;</a></span>deep_size()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">size_t flow::log::deep_size </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="structflow_1_1log_1_1Msg__metadata.html">Msg_metadata</a> &amp;&#160;</td>
          <td class="paramname"><em>val</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Estimate of memory footprint of the given value, including memory allocated on its behalf &ndash; but excluding its shallow <code>sizeof</code>! &ndash; in bytes. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">val</td><td>Value. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>See above. </dd></dl>

</div>
</div>
<a id="acf78eb12c635e06cb37dfbcaac70144d" name="acf78eb12c635e06cb37dfbcaac70144d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#acf78eb12c635e06cb37dfbcaac70144d">&#9670;&nbsp;</a></span>operator!=()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool operator!= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;&#160;</td>
          <td class="paramname"><em>val1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;&#160;</td>
          <td class="paramname"><em>val2</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Returns <code>!(val1 == val2)</code>. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">val1</td><td>Object to compare. </td></tr>
    <tr><td class="paramname">val2</td><td>Object to compare. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>See above. </dd></dl>

</div>
</div>
<a id="a8cf08ca4573526c68e0164a6915b6e44" name="a8cf08ca4573526c68e0164a6915b6e44"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a8cf08ca4573526c68e0164a6915b6e44">&#9670;&nbsp;</a></span>operator&lt;&lt;() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">std::ostream &amp; operator&lt;&lt; </td>
          <td>(</td>
          <td class="paramtype">std::ostream &amp;&#160;</td>
          <td class="paramname"><em>os</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;&#160;</td>
          <td class="paramname"><em>val</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Serializes a <a class="el" href="classflow_1_1log_1_1Verbosity__config.html" title="Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from ...">Verbosity_config</a> to a standard output stream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">os</td><td>Stream to which to serialize. </td></tr>
    <tr><td class="paramname">val</td><td>Value to serialize. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd><code>os</code>. </dd></dl>

</div>
</div>
<a id="a06c8c59ea6c9b36c25b9b8ef319ba501" name="a06c8c59ea6c9b36c25b9b8ef319ba501"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a06c8c59ea6c9b36c25b9b8ef319ba501">&#9670;&nbsp;</a></span>operator&lt;&lt;() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">std::ostream &amp; flow::log::operator&lt;&lt; </td>
          <td>(</td>
          <td class="paramtype">std::ostream &amp;&#160;</td>
          <td class="paramname"><em>os</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">Sev</a>&#160;</td>
          <td class="paramname"><em>val</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Serializes a <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> to a standard output stream. </p>
<p >The output string is compatible with the reverse <code>istream&gt;&gt;</code> operator.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">os</td><td>Stream to which to serialize. </td></tr>
    <tr><td class="paramname">val</td><td>Value to serialize. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd><code>os</code>. </dd></dl>

</div>
</div>
<a id="abfd655adc908d249fe66baf6e8e426e6" name="abfd655adc908d249fe66baf6e8e426e6"></a>
<h2 class="memtitle"><span class="permalink"><a href="#abfd655adc908d249fe66baf6e8e426e6">&#9670;&nbsp;</a></span>operator==()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool operator== </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;&#160;</td>
          <td class="paramname"><em>val1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const <a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;&#160;</td>
          <td class="paramname"><em>val2</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Checks for exact equality of two <a class="el" href="classflow_1_1log_1_1Verbosity__config.html" title="Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from ...">Verbosity_config</a> objects. </p>
<p >(Note that this is not maximally clever, in that if (<code>val1 == val2</code>), then they <em>definitely</em> produce the same <a class="el" href="classflow_1_1log_1_1Config.html" title="Class used to configure the filtering and logging behavior of Loggers; its use in your custom Loggers...">Config</a> all else being equal; but if the reverse is true, then it is possible they differently expressed values producing the same actual result. E.g., something like <code>ALL:INFO</code> differs from <code>ALL:WARN;ALL:INFO</code> &ndash; yet they have the same effect. However component names are normalized internally when parsing, so that won't produce false inequality.)</p>
<p >Only <a class="el" href="classflow_1_1log_1_1Verbosity__config.html#ad71628d526e0933e83d26ef050fc9350" title="Read-only access to encapsulated config; specifies the verbosity-setting calls to make on a Config in...">Verbosity_config::component_sev_pairs()</a> is significant in this comparison; last_result_message() is not.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">val1</td><td>Object to compare. </td></tr>
    <tr><td class="paramname">val2</td><td>Object to compare. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd><code>true</code> if definitely equal; <code>false</code> if possibly not equal. </dd></dl>

</div>
</div>
<a id="a350b25cb85d91052c0fb3dd80d513056" name="a350b25cb85d91052c0fb3dd80d513056"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a350b25cb85d91052c0fb3dd80d513056">&#9670;&nbsp;</a></span>operator&gt;&gt;() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">std::istream &amp; flow::log::operator&gt;&gt; </td>
          <td>(</td>
          <td class="paramtype">std::istream &amp;&#160;</td>
          <td class="paramname"><em>is</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04">Sev</a> &amp;&#160;</td>
          <td class="paramname"><em>val</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Deserializes a <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> from a standard input stream. </p>
<p >Reads up to but not including the next non-alphanumeric-or-underscore character; the resulting string is then mapped to a <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a>. If none is recognized, <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a9ed9d44ce5760f61ea506d5571343624" title="Sentinel log level that must not be specified for any actual message (at risk of undefined behavior s...">Sev::S_NONE</a> is the result. The recognized values are:</p><ul>
<li>"0", "1", ...: Corresponds to the <code>int</code> conversion of that <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> (e.g., 0 being NONE).</li>
<li>Case-insensitive encoding of the non-S_-prefix part of the actual <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">log::Sev</a> member; e.g., "warning" (or "Warning" or "WARNING" or...) for <code>S_WARNING</code>. This enables a few key things to work, including parsing from config file/command line via and conversion from <code>string</code> via <code>boost::lexical_cast</code>.</li>
</ul>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">is</td><td>Stream from which to deserialize. </td></tr>
    <tr><td class="paramname">val</td><td>Value to set. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd><code>is</code>. </dd></dl>

</div>
</div>
<a id="ab7770a6970cce952c422c27f0bf57d8d" name="ab7770a6970cce952c422c27f0bf57d8d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab7770a6970cce952c422c27f0bf57d8d">&#9670;&nbsp;</a></span>operator&gt;&gt;() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">std::istream &amp; operator&gt;&gt; </td>
          <td>(</td>
          <td class="paramtype">std::istream &amp;&#160;</td>
          <td class="paramname"><em>is</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="classflow_1_1log_1_1Verbosity__config.html">Verbosity_config</a> &amp;&#160;</td>
          <td class="paramname"><em>val</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Deserializes a <a class="el" href="classflow_1_1log_1_1Verbosity__config.html" title="Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from ...">Verbosity_config</a> from a standard input stream by invoking <code>val.parse(is)</code>. </p>
<p ><code>val.last_result_message()</code> can be used to glean the success or failure of this operation.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">is</td><td>Stream from which to deserialize. </td></tr>
    <tr><td class="paramname">val</td><td>Value to set. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd><code>is</code>. </dd></dl>

</div>
</div>
<a id="a1b475cd2cc2e476aa96c002927bf1690" name="a1b475cd2cc2e476aa96c002927bf1690"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a1b475cd2cc2e476aa96c002927bf1690">&#9670;&nbsp;</a></span>swap()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void flow::log::swap </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classflow_1_1log_1_1Log__context.html">Log_context</a> &amp;&#160;</td>
          <td class="paramname"><em>val1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="classflow_1_1log_1_1Log__context.html">Log_context</a> &amp;&#160;</td>
          <td class="paramname"><em>val2</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p><a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">Log_context</a> ADL-friendly swap: Equivalent to <code>val1.swap(val2)</code>. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">val1</td><td>Object. </td></tr>
    <tr><td class="paramname">val2</td><td>Object. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated on Fri Mar 28 2025 22:55:32 for Flow by&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.4
</small></address>
</body>
</html>
